/* Zepto v1.2.0 - zepto event ajax form ie - zeptojs.com/license */
(function ( global, factory ) {
	if ( typeof exports !== "undefined" ) {
		if ( typeof module !== "undefined" && module.exports ) {
			exports = module.exports = factory( global );
		}
	} else if ( typeof define === 'function' && define.amd )
		define( function () {
			return factory( global )
		} )
	else
		factory( global )
}( window, function ( window ) {
	var Zepto = (function () {
		var undefined, key, $, classList, emptyArray = [],
			concat = emptyArray.concat,
			filter = emptyArray.filter,
			slice = emptyArray.slice,
			document = window.document,
			elementDisplay = {},
			classCache = {},
			cssNumber = {
				'column-count': 1,
				'columns': 1,
				'font-weight': 1,
				'line-height': 1,
				'opacity': 1,
				'z-index': 1,
				'zoom': 1
			},
			fragmentRE = /^\s*<(\w+|!)[^>]*>/,
			singleTagRE = /^<(\w+)\s*\/?>(?:<\/\1>|)$/,
			tagExpanderRE = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,
			rootNodeRE = /^(?:body|html)$/i,
			capitalRE = /([A-Z])/g,

			// special attributes that should be get/set via method calls
			methodAttributes = [ 'val', 'css', 'html', 'text', 'data', 'width', 'height', 'offset' ],

			adjacencyOperators = [ 'after', 'prepend', 'before', 'append' ],
			table = document.createElement( 'table' ),
			tableRow = document.createElement( 'tr' ),
			containers = {
				'tr': document.createElement( 'tbody' ),
				'tbody': table,
				'thead': table,
				'tfoot': table,
				'td': tableRow,
				'th': tableRow,
				'*': document.createElement( 'div' )
			},
			readyRE = /complete|loaded|interactive/,
			simpleSelectorRE = /^[\w-]*$/,
			class2type = {},
			toString = class2type.toString,
			zepto = {},
			camelize, uniq,
			tempParent = document.createElement( 'div' ),
			propMap = {
				'tabindex': 'tabIndex',
				'readonly': 'readOnly',
				'for': 'htmlFor',
				'class': 'className',
				'maxlength': 'maxLength',
				'cellspacing': 'cellSpacing',
				'cellpadding': 'cellPadding',
				'rowspan': 'rowSpan',
				'colspan': 'colSpan',
				'usemap': 'useMap',
				'frameborder': 'frameBorder',
				'contenteditable': 'contentEditable'
			},
			isArray = Array.isArray ||
				function ( object ) {
					return object instanceof Array
				}

		zepto.matches = function ( element, selector ) {
			if ( !selector || !element || element.nodeType !== 1 ) return false
			var matchesSelector = element.matches || element.webkitMatchesSelector ||
				element.mozMatchesSelector || element.oMatchesSelector ||
				element.matchesSelector
			if ( matchesSelector ) return matchesSelector.call( element, selector )
			// fall back to performing a selector:
			var match, parent = element.parentNode,
				temp = !parent
			if ( temp )(parent = tempParent).appendChild( element )
			match = ~zepto.qsa( parent, selector ).indexOf( element )
			temp && tempParent.removeChild( element )
			return match
		}

		function type( obj ) {
			return obj == null ? String( obj ) :
			class2type[ toString.call( obj ) ] || "object"
		}

		function isFunction( value ) {
			return type( value ) == "function"
		}

		function isWindow( obj ) {
			return obj != null && obj == obj.window
		}

		function isDocument( obj ) {
			return obj != null && obj.nodeType == obj.DOCUMENT_NODE
		}

		function isObject( obj ) {
			return type( obj ) == "object"
		}

		function isPlainObject( obj ) {
			return isObject( obj ) && !isWindow( obj ) && Object.getPrototypeOf( obj ) == Object.prototype
		}

		function likeArray( obj ) {
			var length = !!obj && 'length' in obj && obj.length,
				type = $.type( obj )

			return 'function' != type && !isWindow( obj ) && (
					'array' == type || length === 0 ||
					(typeof length == 'number' && length > 0 && (length - 1) in obj)
				)
		}

		function compact( array ) {
			return filter.call( array, function ( item ) {
				return item != null
			} )
		}

		function flatten( array ) {
			return array.length > 0 ? $.fn.concat.apply( [], array ) : array
		}

		camelize = function ( str ) {
			return str.replace( /-+(.)?/g, function ( match, chr ) {
				return chr ? chr.toUpperCase() : ''
			} )
		}

		function dasherize( str ) {
			return str.replace( /::/g, '/' )
				.replace( /([A-Z]+)([A-Z][a-z])/g, '$1_$2' )
				.replace( /([a-z\d])([A-Z])/g, '$1_$2' )
				.replace( /_/g, '-' )
				.toLowerCase()
		}

		uniq = function ( array ) {
			return filter.call( array, function ( item, idx ) {
				return array.indexOf( item ) == idx
			} )
		}

		function classRE( name ) {
			return name in classCache ?
				classCache[ name ] : (classCache[ name ] = new RegExp( '(^|\\s)' + name + '(\\s|$)' ))
		}

		function maybeAddPx( name, value ) {
			return (typeof value == "number" && !cssNumber[ dasherize( name ) ]) ? value + "px" : value
		}

		function defaultDisplay( nodeName ) {
			var element, display
			if ( !elementDisplay[ nodeName ] ) {
				element = document.createElement( nodeName )
				document.body.appendChild( element )
				display = getComputedStyle( element, '' ).getPropertyValue( "display" )
				element.parentNode.removeChild( element )
				display == "none" && (display = "block")
				elementDisplay[ nodeName ] = display
			}
			return elementDisplay[ nodeName ]
		}

		function children( element ) {
			return 'children' in element ?
				slice.call( element.children ) :
				$.map( element.childNodes, function ( node ) {
					if ( node.nodeType == 1 ) return node
				} )
		}

		function Z( dom, selector ) {
			var i, len = dom ? dom.length : 0
			for ( i = 0; i < len; i++ ) this[ i ] = dom[ i ]
			this.length = len
			this.selector = selector || ''
		}

		// `$.zepto.fragment` takes a html string and an optional tag name
		// to generate DOM nodes from the given html string.
		// The generated DOM nodes are returned as an array.
		// This function can be overridden in plugins for example to make
		// it compatible with browsers that don't support the DOM fully.
		zepto.fragment = function ( html, name, properties ) {
			var dom, nodes, container

			// A special case optimization for a single tag
			if ( singleTagRE.test( html ) ) dom = $( document.createElement( RegExp.$1 ) )

			if ( !dom ) {
				if ( html.replace ) html = html.replace( tagExpanderRE, "<$1></$2>" )
				if ( name === undefined ) name = fragmentRE.test( html ) && RegExp.$1
				if ( !(name in containers) ) name = '*'

				container = containers[ name ]
				container.innerHTML = '' + html
				dom = $.each( slice.call( container.childNodes ), function () {
					container.removeChild( this )
				} )
			}

			if ( isPlainObject( properties ) ) {
				nodes = $( dom )
				$.each( properties, function ( key, value ) {
					if ( methodAttributes.indexOf( key ) > -1 ) nodes[ key ]( value )
					else nodes.attr( key, value )
				} )
			}

			return dom
		}

		// `$.zepto.Z` swaps out the prototype of the given `dom` array
		// of nodes with `$.fn` and thus supplying all the Zepto functions
		// to the array. This method can be overridden in plugins.
		zepto.Z = function ( dom, selector ) {
			return new Z( dom, selector )
		}

		// `$.zepto.isZ` should return `true` if the given object is a Zepto
		// collection. This method can be overridden in plugins.
		zepto.isZ = function ( object ) {
			return object instanceof zepto.Z
		}

		// `$.zepto.init` is Zepto's counterpart to jQuery's `$.fn.init` and
		// takes a CSS selector and an optional context (and handles various
		// special cases).
		// This method can be overridden in plugins.
		zepto.init = function ( selector, context ) {
			var dom
			// If nothing given, return an empty Zepto collection
			if ( !selector ) return zepto.Z()
			// Optimize for string selectors
			else if ( typeof selector == 'string' ) {
				selector = selector.trim()
				// If it's a html fragment, create nodes from it
				// Note: In both Chrome 21 and Firefox 15, DOM error 12
				// is thrown if the fragment doesn't begin with <
				if ( selector[ 0 ] == '<' && fragmentRE.test( selector ) )
					dom = zepto.fragment( selector, RegExp.$1, context ), selector = null
				// If there's a context, create a collection on that context first, and select
				// nodes from there
				else if ( context !== undefined ) return $( context ).find( selector )
				// If it's a CSS selector, use it to select nodes.
				else dom = zepto.qsa( document, selector )
			}
			// If a function is given, call it when the DOM is ready
			else if ( isFunction( selector ) ) return $( document ).ready( selector )
			// If a Zepto collection is given, just return it
			else if ( zepto.isZ( selector ) ) return selector
			else {
				// normalize array if an array of nodes is given
				if ( isArray( selector ) ) dom = compact( selector )
				// Wrap DOM nodes.
				else if ( isObject( selector ) )
					dom = [ selector ], selector = null
				// If it's a html fragment, create nodes from it
				else if ( fragmentRE.test( selector ) )
					dom = zepto.fragment( selector.trim(), RegExp.$1, context ), selector = null
				// If there's a context, create a collection on that context first, and select
				// nodes from there
				else if ( context !== undefined ) return $( context ).find( selector )
				// And last but no least, if it's a CSS selector, use it to select nodes.
				else dom = zepto.qsa( document, selector )
			}
			// create a new Zepto collection from the nodes found
			return zepto.Z( dom, selector )
		}

		// `$` will be the base `Zepto` object. When calling this
		// function just call `$.zepto.init, which makes the implementation
		// details of selecting nodes and creating Zepto collections
		// patchable in plugins.
		$ = function ( selector, context ) {
			return zepto.init( selector, context )
		}

		function extend( target, source, deep ) {
			for ( key in source )
				if ( deep && (isPlainObject( source[ key ] ) || isArray( source[ key ] )) ) {
					if ( isPlainObject( source[ key ] ) && !isPlainObject( target[ key ] ) )
						target[ key ] = {}
					if ( isArray( source[ key ] ) && !isArray( target[ key ] ) )
						target[ key ] = []
					extend( target[ key ], source[ key ], deep )
				} else if ( source[ key ] !== undefined ) target[ key ] = source[ key ]
		}

		// Copy all but undefined properties from one or more
		// objects to the `target` object.
		$.extend = function ( target ) {
			var deep, args = slice.call( arguments, 1 )
			if ( typeof target == 'boolean' ) {
				deep = target
				target = args.shift()
			}
			args.forEach( function ( arg ) {
				extend( target, arg, deep )
			} )
			return target
		}

		// `$.zepto.qsa` is Zepto's CSS selector implementation which
		// uses `document.querySelectorAll` and optimizes for some special cases, like `#id`.
		// This method can be overridden in plugins.
		zepto.qsa = function ( element, selector ) {
			var found,
				maybeID = selector[ 0 ] == '#',
				maybeClass = !maybeID && selector[ 0 ] == '.',
				nameOnly = maybeID || maybeClass ? selector.slice( 1 ) : selector, // Ensure that a 1 char tag name still gets checked
				isSimple = simpleSelectorRE.test( nameOnly )
			return (element.getElementById && isSimple && maybeID) ? // Safari DocumentFragment doesn't have getElementById
				((found = element.getElementById( nameOnly )) ? [ found ] : []) :
				(element.nodeType !== 1 && element.nodeType !== 9 && element.nodeType !== 11) ? [] :
					slice.call(
						isSimple && !maybeID && element.getElementsByClassName ? // DocumentFragment doesn't have getElementsByClassName/TagName
							maybeClass ? element.getElementsByClassName( nameOnly ) : // If it's simple, it could be a class
								element.getElementsByTagName( selector ) : // Or a tag
							element.querySelectorAll( selector ) // Or it's not simple, and we need to query all
					)
		}

		function filtered( nodes, selector ) {
			return selector == null ? $( nodes ) : $( nodes ).filter( selector )
		}

		$.contains = document.documentElement.contains ?
			function ( parent, node ) {
				return parent !== node && parent.contains( node )
			} :
			function ( parent, node ) {
				while ( node && (node = node.parentNode) )
					if ( node === parent ) return true
				return false
			}

		function funcArg( context, arg, idx, payload ) {
			return isFunction( arg ) ? arg.call( context, idx, payload ) : arg
		}

		function setAttribute( node, name, value ) {
			value == null ? node.removeAttribute( name ) : node.setAttribute( name, value )
		}

		// access className property while respecting SVGAnimatedString
		function className( node, value ) {
			var klass = node.className || '',
				svg = klass && klass.baseVal !== undefined

			if ( value === undefined ) return svg ? klass.baseVal : klass
			svg ? (klass.baseVal = value) : (node.className = value)
		}

		// "true"  => true
		// "false" => false
		// "null"  => null
		// "42"    => 42
		// "42.5"  => 42.5
		// "08"    => "08"
		// JSON    => parse if valid
		// String  => self
		function deserializeValue( value ) {
			try {
				return value ?
				value == "true" ||
				(value == "false" ? false :
					value == "null" ? null :
						+value + "" == value ? +value :
							/^[\[\{]/.test( value ) ? $.parseJSON( value ) :
								value) :
					value
			} catch ( e ) {
				return value
			}
		}

		$.type = type
		$.isFunction = isFunction
		$.isWindow = isWindow
		$.isArray = isArray
		$.isPlainObject = isPlainObject

		$.isEmptyObject = function ( obj ) {
			var name
			for ( name in obj ) return false
			return true
		}

		$.isNumeric = function ( val ) {
			var num = Number( val ),
				type = typeof val
			return val != null && type != 'boolean' &&
				(type != 'string' || val.length) && !isNaN( num ) && isFinite( num ) || false
		}

		$.inArray = function ( elem, array, i ) {
			return emptyArray.indexOf.call( array, elem, i )
		}

		$.camelCase = camelize
		$.trim = function ( str ) {
			return str == null ? "" : String.prototype.trim.call( str )
		}

		// plugin compatibility
		$.uuid = 0
		$.support = {}
		$.expr = {}
		$.noop = function () {
		}

		$.map = function ( elements, callback ) {
			var value, values = [],
				i, key
			if ( likeArray( elements ) )
				for ( i = 0; i < elements.length; i++ ) {
					value = callback( elements[ i ], i )
					if ( value != null ) values.push( value )
				}
			else
				for ( key in elements ) {
					value = callback( elements[ key ], key )
					if ( value != null ) values.push( value )
				}
			return flatten( values )
		}

		$.each = function ( elements, callback ) {
			var i, key
			if ( likeArray( elements ) ) {
				for ( i = 0; i < elements.length; i++ )
					if ( callback.call( elements[ i ], i, elements[ i ] ) === false ) return elements
			} else {
				for ( key in elements )
					if ( callback.call( elements[ key ], key, elements[ key ] ) === false ) return elements
			}

			return elements
		}

		$.grep = function ( elements, callback ) {
			return filter.call( elements, callback )
		}

		if ( window.JSON ) $.parseJSON = JSON.parse

		// Populate the class2type map
		$.each( "Boolean Number String Function Array Date RegExp Object Error".split( " " ), function ( i, name ) {
			class2type[ "[object " + name + "]" ] = name.toLowerCase()
		} )

		// Define methods that will be available on all
		// Zepto collections
		$.fn = {
			constructor: zepto.Z,
			length: 0,

			// Because a collection acts like an array
			// copy over these useful array functions.
			forEach: emptyArray.forEach,
			reduce: emptyArray.reduce,
			push: emptyArray.push,
			sort: emptyArray.sort,
			splice: emptyArray.splice,
			indexOf: emptyArray.indexOf,
			concat: function () {
				var i, value, args = []
				for ( i = 0; i < arguments.length; i++ ) {
					value = arguments[ i ]
					args[ i ] = zepto.isZ( value ) ? value.toArray() : value
				}
				return concat.apply( zepto.isZ( this ) ? this.toArray() : this, args )
			},

			// `map` and `slice` in the jQuery API work differently
			// from their array counterparts
			map: function ( fn ) {
				return $( $.map( this, function ( el, i ) {
					return fn.call( el, i, el )
				} ) )
			},
			slice: function () {
				return $( slice.apply( this, arguments ) )
			},

			ready: function ( callback ) {
				// need to check if document.body exists for IE as that browser reports
				// document ready when it hasn't yet created the body element
				if ( readyRE.test( document.readyState ) && document.body ) callback( $ )
				else document.addEventListener( 'DOMContentLoaded', function () {
					callback( $ )
				}, false )
				return this
			},
			get: function ( idx ) {
				return idx === undefined ? slice.call( this ) : this[ idx >= 0 ? idx : idx + this.length ]
			},
			toArray: function () {
				return this.get()
			},
			size: function () {
				return this.length
			},
			remove: function () {
				return this.each( function () {
					if ( this.parentNode != null )
						this.parentNode.removeChild( this )
				} )
			},
			each: function ( callback ) {
				emptyArray.every.call( this, function ( el, idx ) {
					return callback.call( el, idx, el ) !== false
				} )
				return this
			},
			filter: function ( selector ) {
				if ( isFunction( selector ) ) return this.not( this.not( selector ) )
				return $( filter.call( this, function ( element ) {
					return zepto.matches( element, selector )
				} ) )
			},
			add: function ( selector, context ) {
				return $( uniq( this.concat( $( selector, context ) ) ) )
			},
			is: function ( selector ) {
				return this.length > 0 && zepto.matches( this[ 0 ], selector )
			},
			not: function ( selector ) {
				var nodes = []
				if ( isFunction( selector ) && selector.call !== undefined )
					this.each( function ( idx ) {
						if ( !selector.call( this, idx ) ) nodes.push( this )
					} )
				else {
					var excludes = typeof selector == 'string' ? this.filter( selector ) :
						(likeArray( selector ) && isFunction( selector.item )) ? slice.call( selector ) : $( selector )
					this.forEach( function ( el ) {
						if ( excludes.indexOf( el ) < 0 ) nodes.push( el )
					} )
				}
				return $( nodes )
			},
			has: function ( selector ) {
				return this.filter( function () {
					return isObject( selector ) ?
						$.contains( this, selector ) :
						$( this ).find( selector ).size()
				} )
			},
			eq: function ( idx ) {
				return idx === -1 ? this.slice( idx ) : this.slice( idx, +idx + 1 )
			},
			first: function () {
				var el = this[ 0 ]
				return el && !isObject( el ) ? el : $( el )
			},
			last: function () {
				var el = this[ this.length - 1 ]
				return el && !isObject( el ) ? el : $( el )
			},
			find: function ( selector ) {
				var result, $this = this
				if ( !selector ) result = $()
				else if ( typeof selector == 'object' )
					result = $( selector ).filter( function () {
						var node = this
						return emptyArray.some.call( $this, function ( parent ) {
							return $.contains( parent, node )
						} )
					} )
				else if ( this.length == 1 ) result = $( zepto.qsa( this[ 0 ], selector ) )
				else result = this.map( function () {
						return zepto.qsa( this, selector )
					} )
				return result
			},
			closest: function ( selector, context ) {
				var nodes = [],
					collection = typeof selector == 'object' && $( selector )
				this.each( function ( _, node ) {
					while ( node && !(collection ? collection.indexOf( node ) >= 0 : zepto.matches( node, selector )) )
						node = node !== context && !isDocument( node ) && node.parentNode
					if ( node && nodes.indexOf( node ) < 0 ) nodes.push( node )
				} )
				return $( nodes )
			},
			parents: function ( selector ) {
				var ancestors = [],
					nodes = this
				while ( nodes.length > 0 )
					nodes = $.map( nodes, function ( node ) {
						if ( (node = node.parentNode) && !isDocument( node ) && ancestors.indexOf( node ) < 0 ) {
							ancestors.push( node )
							return node
						}
					} )
				return filtered( ancestors, selector )
			},
			parent: function ( selector ) {
				return filtered( uniq( this.pluck( 'parentNode' ) ), selector )
			},
			children: function ( selector ) {
				return filtered( this.map( function () {
					return children( this )
				} ), selector )
			},
			contents: function () {
				return this.map( function () {
					return this.contentDocument || slice.call( this.childNodes )
				} )
			},
			siblings: function ( selector ) {
				return filtered( this.map( function ( i, el ) {
					return filter.call( children( el.parentNode ), function ( child ) {
						return child !== el
					} )
				} ), selector )
			},
			empty: function () {
				return this.each( function () {
					this.innerHTML = ''
				} )
			},
			// `pluck` is borrowed from Prototype.js
			pluck: function ( property ) {
				return $.map( this, function ( el ) {
					return el[ property ]
				} )
			},
			show: function () {
				return this.each( function () {
					this.style.display == "none" && (this.style.display = '')
					if ( getComputedStyle( this, '' ).getPropertyValue( "display" ) == "none" )
						this.style.display = defaultDisplay( this.nodeName )
				} )
			},
			replaceWith: function ( newContent ) {
				return this.before( newContent ).remove()
			},
			wrap: function ( structure ) {
				var func = isFunction( structure )
				if ( this[ 0 ] && !func )
					var dom = $( structure ).get( 0 ),
						clone = dom.parentNode || this.length > 1

				return this.each( function ( index ) {
					$( this ).wrapAll(
						func ? structure.call( this, index ) :
							clone ? dom.cloneNode( true ) : dom
					)
				} )
			},
			wrapAll: function ( structure ) {
				if ( this[ 0 ] ) {
					$( this[ 0 ] ).before( structure = $( structure ) )
					var children
					// drill down to the inmost element
					while ( (children = structure.children()).length ) structure = children.first()
					$( structure ).append( this )
				}
				return this
			},
			wrapInner: function ( structure ) {
				var func = isFunction( structure )
				return this.each( function ( index ) {
					var self = $( this ),
						contents = self.contents(),
						dom = func ? structure.call( this, index ) : structure
					contents.length ? contents.wrapAll( dom ) : self.append( dom )
				} )
			},
			unwrap: function () {
				this.parent().each( function () {
					$( this ).replaceWith( $( this ).children() )
				} )
				return this
			},
			clone: function () {
				return this.map( function () {
					return this.cloneNode( true )
				} )
			},
			hide: function () {
				return this.css( "display", "none" )
			},
			toggle: function ( setting ) {
				return this.each( function () {
					var el = $( this );
					(setting === undefined ? el.css( "display" ) == "none" : setting) ? el.show() : el.hide()
				} )
			},
			prev: function ( selector ) {
				return $( this.pluck( 'previousElementSibling' ) ).filter( selector || '*' )
			},
			next: function ( selector ) {
				return $( this.pluck( 'nextElementSibling' ) ).filter( selector || '*' )
			},
			html: function ( html ) {
				return 0 in arguments ?
					this.each( function ( idx ) {
						var originHtml = this.innerHTML
						$( this ).empty().append( funcArg( this, html, idx, originHtml ) )
					} ) :
					(0 in this ? this[ 0 ].innerHTML : null)
			},
			text: function ( text ) {
				return 0 in arguments ?
					this.each( function ( idx ) {
						var newText = funcArg( this, text, idx, this.textContent )
						this.textContent = newText == null ? '' : '' + newText
					} ) :
					(0 in this ? this.pluck( 'textContent' ).join( "" ) : null)
			},
			attr: function ( name, value ) {
				var result
				return (typeof name == 'string' && !(1 in arguments)) ?
					(0 in this && this[ 0 ].nodeType == 1 && (result = this[ 0 ].getAttribute( name )) != null ? result : undefined) :
					this.each( function ( idx ) {
						if ( this.nodeType !== 1 ) return
						if ( isObject( name ) )
							for ( key in name ) setAttribute( this, key, name[ key ] )
						else setAttribute( this, name, funcArg( this, value, idx, this.getAttribute( name ) ) )
					} )
			},
			removeAttr: function ( name ) {
				return this.each( function () {
					this.nodeType === 1 && name.split( ' ' ).forEach( function ( attribute ) {
						setAttribute( this, attribute )
					}, this )
				} )
			},
			prop: function ( name, value ) {
				name = propMap[ name ] || name
				return (1 in arguments) ?
					this.each( function ( idx ) {
						this[ name ] = funcArg( this, value, idx, this[ name ] )
					} ) :
					(this[ 0 ] && this[ 0 ][ name ])
			},
			removeProp: function ( name ) {
				name = propMap[ name ] || name
				return this.each( function () {
					delete this[ name ]
				} )
			},
			data: function ( name, value ) {
				var attrName = 'data-' + name.replace( capitalRE, '-$1' ).toLowerCase()

				var data = (1 in arguments) ?
					this.attr( attrName, value ) :
					this.attr( attrName )

				return data !== null ? deserializeValue( data ) : undefined
			},
			val: function ( value ) {
				if ( 0 in arguments ) {
					if ( value == null ) value = ""
					return this.each( function ( idx ) {
						this.value = funcArg( this, value, idx, this.value )
					} )
				} else {
					return this[ 0 ] && (this[ 0 ].multiple ?
							$( this[ 0 ] ).find( 'option' ).filter( function () {
								return this.selected
							} ).pluck( 'value' ) :
							this[ 0 ].value)
				}
			},
			offset: function ( coordinates ) {
				if ( coordinates ) return this.each( function ( index ) {
					var $this = $( this ),
						coords = funcArg( this, coordinates, index, $this.offset() ),
						parentOffset = $this.offsetParent().offset(),
						props = {
							top: coords.top - parentOffset.top,
							left: coords.left - parentOffset.left
						}

					if ( $this.css( 'position' ) == 'static' ) props[ 'position' ] = 'relative'
					$this.css( props )
				} )
				if ( !this.length ) return null
				if ( document.documentElement !== this[ 0 ] && !$.contains( document.documentElement, this[ 0 ] ) )
					return {
						top: 0,
						left: 0
					}
				var obj = this[ 0 ].getBoundingClientRect()
				return {
					left: obj.left + window.pageXOffset,
					top: obj.top + window.pageYOffset,
					width: Math.round( obj.width ),
					height: Math.round( obj.height )
				}
			},
			css: function ( property, value ) {
				if ( arguments.length < 2 ) {
					var element = this[ 0 ]
					if ( typeof property == 'string' ) {
						if ( !element ) return
						return element.style[ camelize( property ) ] || getComputedStyle( element, '' ).getPropertyValue( property )
					} else if ( isArray( property ) ) {
						if ( !element ) return
						var props = {}
						var computedStyle = getComputedStyle( element, '' )
						$.each( property, function ( _, prop ) {
							props[ prop ] = (element.style[ camelize( prop ) ] || computedStyle.getPropertyValue( prop ))
						} )
						return props
					}
				}

				var css = ''
				if ( type( property ) == 'string' ) {
					if ( !value && value !== 0 )
						this.each( function () {
							this.style.removeProperty( dasherize( property ) )
						} )
					else
						css = dasherize( property ) + ":" + maybeAddPx( property, value )
				} else {
					for ( key in property )
						if ( !property[ key ] && property[ key ] !== 0 )
							this.each( function () {
								this.style.removeProperty( dasherize( key ) )
							} )
						else
							css += dasherize( key ) + ':' + maybeAddPx( key, property[ key ] ) + ';'
				}

				return this.each( function () {
					this.style.cssText += ';' + css
				} )
			},
			index: function ( element ) {
				return element ? this.indexOf( $( element )[ 0 ] ) : this.parent().children().indexOf( this[ 0 ] )
			},
			hasClass: function ( name ) {
				if ( !name ) return false
				return emptyArray.some.call( this, function ( el ) {
					return this.test( className( el ) )
				}, classRE( name ) )
			},
			addClass: function ( name ) {
				if ( !name ) return this
				return this.each( function ( idx ) {
					if ( !('className' in this) ) return
					classList = []
					var cls = className( this ),
						newName = funcArg( this, name, idx, cls )
					newName.split( /\s+/g ).forEach( function ( klass ) {
						if ( !$( this ).hasClass( klass ) ) classList.push( klass )
					}, this )
					classList.length && className( this, cls + (cls ? " " : "") + classList.join( " " ) )
				} )
			},
			removeClass: function ( name ) {
				return this.each( function ( idx ) {
					if ( !('className' in this) ) return
					if ( name === undefined ) return className( this, '' )
					classList = className( this )
					funcArg( this, name, idx, classList ).split( /\s+/g ).forEach( function ( klass ) {
						classList = classList.replace( classRE( klass ), " " )
					} )
					className( this, classList.trim() )
				} )
			},
			toggleClass: function ( name, when ) {
				if ( !name ) return this
				return this.each( function ( idx ) {
					var $this = $( this ),
						names = funcArg( this, name, idx, className( this ) )
					names.split( /\s+/g ).forEach( function ( klass ) {
						(when === undefined ? !$this.hasClass( klass ) : when) ?
							$this.addClass( klass ) : $this.removeClass( klass )
					} )
				} )
			},
			scrollTop: function ( value ) {
				if ( !this.length ) return
				var hasScrollTop = 'scrollTop' in this[ 0 ]
				if ( value === undefined ) return hasScrollTop ? this[ 0 ].scrollTop : this[ 0 ].pageYOffset
				return this.each( hasScrollTop ?
					function () {
						this.scrollTop = value
					} :
					function () {
						this.scrollTo( this.scrollX, value )
					} )
			},
			scrollLeft: function ( value ) {
				if ( !this.length ) return
				var hasScrollLeft = 'scrollLeft' in this[ 0 ]
				if ( value === undefined ) return hasScrollLeft ? this[ 0 ].scrollLeft : this[ 0 ].pageXOffset
				return this.each( hasScrollLeft ?
					function () {
						this.scrollLeft = value
					} :
					function () {
						this.scrollTo( value, this.scrollY )
					} )
			},
			position: function () {
				if ( !this.length ) return

				var elem = this[ 0 ],
					// Get *real* offsetParent
					offsetParent = this.offsetParent(),
					// Get correct offsets
					offset = this.offset(),
					parentOffset = rootNodeRE.test( offsetParent[ 0 ].nodeName ) ? {
						top: 0,
						left: 0
					} : offsetParent.offset()

				// Subtract element margins
				// note: when an element has margin: auto the offsetLeft and marginLeft
				// are the same in Safari causing offset.left to incorrectly be 0
				offset.top -= parseFloat( $( elem ).css( 'margin-top' ) ) || 0
				offset.left -= parseFloat( $( elem ).css( 'margin-left' ) ) || 0

				// Add offsetParent borders
				parentOffset.top += parseFloat( $( offsetParent[ 0 ] ).css( 'border-top-width' ) ) || 0
				parentOffset.left += parseFloat( $( offsetParent[ 0 ] ).css( 'border-left-width' ) ) || 0

				// Subtract the two offsets
				return {
					top: offset.top - parentOffset.top,
					left: offset.left - parentOffset.left
				}
			},
			offsetParent: function () {
				return this.map( function () {
					var parent = this.offsetParent || document.body
					while ( parent && !rootNodeRE.test( parent.nodeName ) && $( parent ).css( "position" ) == "static" )
						parent = parent.offsetParent
					return parent
				} )
			}
		}

		// for now
		$.fn.detach = $.fn.remove

		// Generate the `width` and `height` functions
		;
		[ 'width', 'height' ].forEach( function ( dimension ) {
			var dimensionProperty =
				dimension.replace( /./, function ( m ) {
					return m[ 0 ].toUpperCase()
				} )

			$.fn[ dimension ] = function ( value ) {
				var offset, el = this[ 0 ]
				if ( value === undefined ) return isWindow( el ) ? el[ 'inner' + dimensionProperty ] :
					isDocument( el ) ? el.documentElement[ 'scroll' + dimensionProperty ] :
					(offset = this.offset()) && offset[ dimension ]
				else return this.each( function ( idx ) {
					el = $( this )
					el.css( dimension, funcArg( this, value, idx, el[ dimension ]() ) )
				} )
			}
		} )

		function traverseNode( node, fun ) {
			fun( node )
			for ( var i = 0, len = node.childNodes.length; i < len; i++ )
				traverseNode( node.childNodes[ i ], fun )
		}

		// Generate the `after`, `prepend`, `before`, `append`,
		// `insertAfter`, `insertBefore`, `appendTo`, and `prependTo` methods.
		adjacencyOperators.forEach( function ( operator, operatorIndex ) {
			var inside = operatorIndex % 2 //=> prepend, append

			$.fn[ operator ] = function () {
				// arguments can be nodes, arrays of nodes, Zepto objects and HTML strings
				var argType, nodes = $.map( arguments, function ( arg ) {
						var arr = []
						argType = type( arg )
						if ( argType == "array" ) {
							arg.forEach( function ( el ) {
								if ( el.nodeType !== undefined ) return arr.push( el )
								else if ( $.zepto.isZ( el ) ) return arr = arr.concat( el.get() )
								arr = arr.concat( zepto.fragment( el ) )
							} )
							return arr
						}
						return argType == "object" || arg == null ?
							arg : zepto.fragment( arg )
					} ),
					parent, copyByClone = this.length > 1
				if ( nodes.length < 1 ) return this

				return this.each( function ( _, target ) {
					parent = inside ? target : target.parentNode

					// convert all methods to a "before" operation
					target = operatorIndex == 0 ? target.nextSibling :
						operatorIndex == 1 ? target.firstChild :
							operatorIndex == 2 ? target :
								null

					var parentInDocument = $.contains( document.documentElement, parent )

					nodes.forEach( function ( node ) {
						if ( copyByClone ) node = node.cloneNode( true )
						else if ( !parent ) return $( node ).remove()

						parent.insertBefore( node, target )
						if ( parentInDocument ) traverseNode( node, function ( el ) {
							if ( el.nodeName != null && el.nodeName.toUpperCase() === 'SCRIPT' &&
								(!el.type || el.type === 'text/javascript') && !el.src ) {
								var target = el.ownerDocument ? el.ownerDocument.defaultView : window
								target[ 'eval' ].call( target, el.innerHTML )
							}
						} )
					} )
				} )
			}

			// after    => insertAfter
			// prepend  => prependTo
			// before   => insertBefore
			// append   => appendTo
			$.fn[ inside ? operator + 'To' : 'insert' + (operatorIndex ? 'Before' : 'After') ] = function ( html ) {
				$( html )[ operator ]( this )
				return this
			}
		} )

		zepto.Z.prototype = Z.prototype = $.fn

		// Export internal API functions in the `$.zepto` namespace
		zepto.uniq = uniq
		zepto.deserializeValue = deserializeValue
		$.zepto = zepto

		return $
	})()

	window.Zepto = Zepto
	window.$ === undefined && (window.$ = Zepto)

	;
	(function ( $ ) {
		var _zid = 1,
			undefined,
			slice = Array.prototype.slice,
			isFunction = $.isFunction,
			isString = function ( obj ) {
				return typeof obj == 'string'
			},
			handlers = {},
			specialEvents = {},
			focusinSupported = 'onfocusin' in window,
			focus = {
				focus: 'focusin',
				blur: 'focusout'
			},
			hover = {
				mouseenter: 'mouseover',
				mouseleave: 'mouseout'
			}

		specialEvents.click = specialEvents.mousedown = specialEvents.mouseup = specialEvents.mousemove = 'MouseEvents'

		function zid( element ) {
			return element._zid || (element._zid = _zid++)
		}

		function findHandlers( element, event, fn, selector ) {
			event = parse( event )
			if ( event.ns ) var matcher = matcherFor( event.ns )
			return (handlers[ zid( element ) ] || []).filter( function ( handler ) {
				return handler &&
					(!event.e || handler.e == event.e) &&
					(!event.ns || matcher.test( handler.ns )) &&
					(!fn || zid( handler.fn ) === zid( fn )) &&
					(!selector || handler.sel == selector)
			} )
		}

		function parse( event ) {
			var parts = ('' + event).split( '.' )
			return {
				e: parts[ 0 ],
				ns: parts.slice( 1 ).sort().join( ' ' )
			}
		}

		function matcherFor( ns ) {
			return new RegExp( '(?:^| )' + ns.replace( ' ', ' .* ?' ) + '(?: |$)' )
		}

		function eventCapture( handler, captureSetting ) {
			return handler.del &&
				(!focusinSupported && (handler.e in focus)) || !!captureSetting
		}

		function realEvent( type ) {
			return hover[ type ] || (focusinSupported && focus[ type ]) || type
		}

		function add( element, events, fn, data, selector, delegator, capture ) {
			var id = zid( element ),
				set = (handlers[ id ] || (handlers[ id ] = []))
			events.split( /\s/ ).forEach( function ( event ) {
				if ( event == 'ready' ) return $( document ).ready( fn )
				var handler = parse( event )
				handler.fn = fn
				handler.sel = selector
				// emulate mouseenter, mouseleave
				if ( handler.e in hover ) fn = function ( e ) {
					var related = e.relatedTarget
					if ( !related || (related !== this && !$.contains( this, related )) )
						return handler.fn.apply( this, arguments )
				}
				handler.del = delegator
				var callback = delegator || fn
				handler.proxy = function ( e ) {
					e = compatible( e )
					if ( e.isImmediatePropagationStopped() ) return
					e.data = data
					var result = callback.apply( element, e._args == undefined ? [ e ] : [ e ].concat( e._args ) )
					if ( result === false ) e.preventDefault(), e.stopPropagation()
					return result
				}
				handler.i = set.length
				set.push( handler )
				if ( 'addEventListener' in element )
					element.addEventListener( realEvent( handler.e ), handler.proxy, eventCapture( handler, capture ) )
			} )
		}

		function remove( element, events, fn, selector, capture ) {
			var id = zid( element );
			(events || '').split( /\s/ ).forEach( function ( event ) {
				findHandlers( element, event, fn, selector ).forEach( function ( handler ) {
					delete handlers[ id ][ handler.i ]
					if ( 'removeEventListener' in element )
						element.removeEventListener( realEvent( handler.e ), handler.proxy, eventCapture( handler, capture ) )
				} )
			} )
		}

		$.event = {
			add: add,
			remove: remove
		}

		$.proxy = function ( fn, context ) {
			var args = (2 in arguments) && slice.call( arguments, 2 )
			if ( isFunction( fn ) ) {
				var proxyFn = function () {
					return fn.apply( context, args ? args.concat( slice.call( arguments ) ) : arguments )
				}
				proxyFn._zid = zid( fn )
				return proxyFn
			} else if ( isString( context ) ) {
				if ( args ) {
					args.unshift( fn[ context ], fn )
					return $.proxy.apply( null, args )
				} else {
					return $.proxy( fn[ context ], fn )
				}
			} else {
				throw new TypeError( "expected function" )
			}
		}

		$.fn.bind = function ( event, data, callback ) {
			return this.on( event, data, callback )
		}
		$.fn.unbind = function ( event, callback ) {
			return this.off( event, callback )
		}
		$.fn.one = function ( event, selector, data, callback ) {
			return this.on( event, selector, data, callback, 1 )
		}

		var returnTrue = function () {
				return true
			},
			returnFalse = function () {
				return false
			},
			ignoreProperties = /^([A-Z]|returnValue$|layer[XY]$|webkitMovement[XY]$)/,
			eventMethods = {
				preventDefault: 'isDefaultPrevented',
				stopImmediatePropagation: 'isImmediatePropagationStopped',
				stopPropagation: 'isPropagationStopped'
			}

		function compatible( event, source ) {
			if ( source || !event.isDefaultPrevented ) {
				source || (source = event)

				$.each( eventMethods, function ( name, predicate ) {
					var sourceMethod = source[ name ]
					event[ name ] = function () {
						this[ predicate ] = returnTrue
						return sourceMethod && sourceMethod.apply( source, arguments )
					}
					event[ predicate ] = returnFalse
				} )

				event.timeStamp || (event.timeStamp = Date.now())

				if ( source.defaultPrevented !== undefined ? source.defaultPrevented :
						'returnValue' in source ? source.returnValue === false :
						source.getPreventDefault && source.getPreventDefault() )
					event.isDefaultPrevented = returnTrue
			}
			return event
		}

		function createProxy( event ) {
			var key, proxy = {
				originalEvent: event
			}
			for ( key in event )
				if ( !ignoreProperties.test( key ) && event[ key ] !== undefined ) proxy[ key ] = event[ key ]

			return compatible( proxy, event )
		}

		$.fn.delegate = function ( selector, event, callback ) {
			return this.on( event, selector, callback )
		}
		$.fn.undelegate = function ( selector, event, callback ) {
			return this.off( event, selector, callback )
		}

		$.fn.live = function ( event, callback ) {
			$( document.body ).delegate( this.selector, event, callback )
			return this
		}
		$.fn.die = function ( event, callback ) {
			$( document.body ).undelegate( this.selector, event, callback )
			return this
		}

		$.fn.on = function ( event, selector, data, callback, one ) {
			var autoRemove, delegator, $this = this
			if ( event && !isString( event ) ) {
				$.each( event, function ( type, fn ) {
					$this.on( type, selector, data, fn, one )
				} )
				return $this
			}

			if ( !isString( selector ) && !isFunction( callback ) && callback !== false )
				callback = data, data = selector, selector = undefined
			if ( callback === undefined || data === false )
				callback = data, data = undefined

			if ( callback === false ) callback = returnFalse

			return $this.each( function ( _, element ) {
				if ( one ) autoRemove = function ( e ) {
					remove( element, e.type, callback )
					return callback.apply( this, arguments )
				}

				if ( selector ) delegator = function ( e ) {
					var evt, match = $( e.target ).closest( selector, element ).get( 0 )
					if ( match && match !== element ) {
						evt = $.extend( createProxy( e ), {
							currentTarget: match,
							liveFired: element
						} )
						return (autoRemove || callback).apply( match, [ evt ].concat( slice.call( arguments, 1 ) ) )
					}
				}

				add( element, event, callback, data, selector, delegator || autoRemove )
			} )
		}
		$.fn.off = function ( event, selector, callback ) {
			var $this = this
			if ( event && !isString( event ) ) {
				$.each( event, function ( type, fn ) {
					$this.off( type, selector, fn )
				} )
				return $this
			}

			if ( !isString( selector ) && !isFunction( callback ) && callback !== false )
				callback = selector, selector = undefined

			if ( callback === false ) callback = returnFalse

			return $this.each( function () {
				remove( this, event, callback, selector )
			} )
		}

		$.fn.trigger = function ( event, args ) {
			event = (isString( event ) || $.isPlainObject( event )) ? $.Event( event ) : compatible( event )
			event._args = args
			return this.each( function () {
				// handle focus(), blur() by calling them directly
				if ( event.type in focus && typeof this[ event.type ] == "function" ) this[ event.type ]()
				// items in the collection might not be DOM elements
				else if ( 'dispatchEvent' in this ) this.dispatchEvent( event )
				else $( this ).triggerHandler( event, args )
			} )
		}

		// triggers event handlers on current element just as if an event occurred,
		// doesn't trigger an actual event, doesn't bubble
		$.fn.triggerHandler = function ( event, args ) {
			var e, result
			this.each( function ( i, element ) {
				e = createProxy( isString( event ) ? $.Event( event ) : event )
				e._args = args
				e.target = element
				$.each( findHandlers( element, event.type || event ), function ( i, handler ) {
					result = handler.proxy( e )
					if ( e.isImmediatePropagationStopped() ) return false
				} )
			} )
			return result
		}

		// shortcut methods for `.bind(event, fn)` for each event type
		;
		('focusin focusout focus blur load resize scroll unload click dblclick ' +
		'mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave ' +
		'change select keydown keypress keyup error').split( ' ' ).forEach( function ( event ) {
			$.fn[ event ] = function ( callback ) {
				return (0 in arguments) ?
					this.bind( event, callback ) :
					this.trigger( event )
			}
		} )

		$.Event = function ( type, props ) {
			if ( !isString( type ) ) props = type, type = props.type
			var event = document.createEvent( specialEvents[ type ] || 'Events' ),
				bubbles = true
			if ( props )
				for ( var name in props )(name == 'bubbles') ? (bubbles = !!props[ name ]) : (event[ name ] = props[ name ])
			event.initEvent( type, bubbles, true )
			return compatible( event )
		}

	})( Zepto )

	;
	(function ( $ ) {
		var jsonpID = +new Date(),
			document = window.document,
			key,
			name,
			rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
			scriptTypeRE = /^(?:text|application)\/javascript/i,
			xmlTypeRE = /^(?:text|application)\/xml/i,
			jsonType = 'application/json',
			htmlType = 'text/html',
			blankRE = /^\s*$/,
			originAnchor = document.createElement( 'a' )

		originAnchor.href = window.location.href

		// trigger a custom event and return false if it was cancelled
		function triggerAndReturn( context, eventName, data ) {
			var event = $.Event( eventName )
			$( context ).trigger( event, data )
			return !event.isDefaultPrevented()
		}

		// trigger an Ajax "global" event
		function triggerGlobal( settings, context, eventName, data ) {
			if ( settings.global ) return triggerAndReturn( context || document, eventName, data )
		}

		// Number of active Ajax requests
		$.active = 0

		function ajaxStart( settings ) {
			if ( settings.global && $.active++ === 0 ) triggerGlobal( settings, null, 'ajaxStart' )
		}

		function ajaxStop( settings ) {
			if ( settings.global && !(--$.active) ) triggerGlobal( settings, null, 'ajaxStop' )
		}

		// triggers an extra global event "ajaxBeforeSend" that's like "ajaxSend" but cancelable
		function ajaxBeforeSend( xhr, settings ) {
			var context = settings.context
			if ( settings.beforeSend.call( context, xhr, settings ) === false ||
				triggerGlobal( settings, context, 'ajaxBeforeSend', [ xhr, settings ] ) === false )
				return false

			triggerGlobal( settings, context, 'ajaxSend', [ xhr, settings ] )
		}

		function ajaxSuccess( data, xhr, settings, deferred ) {
			var context = settings.context,
				status = 'success'
			settings.success.call( context, data, status, xhr )
			if ( deferred ) deferred.resolveWith( context, [ data, status, xhr ] )
			triggerGlobal( settings, context, 'ajaxSuccess', [ xhr, settings, data ] )
			ajaxComplete( status, xhr, settings )
		}

		// type: "timeout", "error", "abort", "parsererror"
		function ajaxError( error, type, xhr, settings, deferred ) {
			var context = settings.context
			settings.error.call( context, xhr, type, error )
			if ( deferred ) deferred.rejectWith( context, [ xhr, type, error ] )
			triggerGlobal( settings, context, 'ajaxError', [ xhr, settings, error || type ] )
			ajaxComplete( type, xhr, settings )
		}

		// status: "success", "notmodified", "error", "timeout", "abort", "parsererror"
		function ajaxComplete( status, xhr, settings ) {
			var context = settings.context
			settings.complete.call( context, xhr, status )
			triggerGlobal( settings, context, 'ajaxComplete', [ xhr, settings ] )
			ajaxStop( settings )
		}

		function ajaxDataFilter( data, type, settings ) {
			if ( settings.dataFilter == empty ) return data
			var context = settings.context
			return settings.dataFilter.call( context, data, type )
		}

		// Empty function, used as default callback
		function empty() {
		}

		$.ajaxJSONP = function ( options, deferred ) {
			if ( !('type' in options) ) return $.ajax( options )

			var _callbackName = options.jsonpCallback,
				callbackName = ($.isFunction( _callbackName ) ?
						_callbackName() : _callbackName) || ('Zepto' + (jsonpID++)),
				script = document.createElement( 'script' ),
				originalCallback = window[ callbackName ],
				responseData,
				abort = function ( errorType ) {
					$( script ).triggerHandler( 'error', errorType || 'abort' )
				},
				xhr = {
					abort: abort
				},
				abortTimeout

			if ( deferred ) deferred.promise( xhr )

			$( script ).on( 'load error', function ( e, errorType ) {
				clearTimeout( abortTimeout )
				$( script ).off().remove()

				if ( e.type == 'error' || !responseData ) {
					ajaxError( null, errorType || 'error', xhr, options, deferred )
				} else {
					ajaxSuccess( responseData[ 0 ], xhr, options, deferred )
				}

				window[ callbackName ] = originalCallback
				if ( responseData && $.isFunction( originalCallback ) )
					originalCallback( responseData[ 0 ] )

				originalCallback = responseData = undefined
			} )

			if ( ajaxBeforeSend( xhr, options ) === false ) {
				abort( 'abort' )
				return xhr
			}

			window[ callbackName ] = function () {
				responseData = arguments
			}

			script.src = options.url.replace( /\?(.+)=\?/, '?$1=' + callbackName )
			document.head.appendChild( script )

			if ( options.timeout > 0 ) abortTimeout = setTimeout( function () {
				abort( 'timeout' )
			}, options.timeout )

			return xhr
		}

		$.ajaxSettings = {
			// Default type of request
			type: 'GET',
			// Callback that is executed before request
			beforeSend: empty,
			// Callback that is executed if the request succeeds
			success: empty,
			// Callback that is executed the the server drops error
			error: empty,
			// Callback that is executed on request complete (both: error and success)
			complete: empty,
			// The context for the callbacks
			context: null,
			// Whether to trigger "global" Ajax events
			global: true,
			// Transport
			xhr: function () {
				return new window.XMLHttpRequest()
			},
			// MIME types mapping
			// IIS returns Javascript as "application/x-javascript"
			accepts: {
				script: 'text/javascript, application/javascript, application/x-javascript',
				json: jsonType,
				xml: 'application/xml, text/xml',
				html: htmlType,
				text: 'text/plain'
			},
			// Whether the request is to another domain
			crossDomain: false,
			// Default timeout
			timeout: 0,
			// Whether data should be serialized to string
			processData: true,
			// Whether the browser should be allowed to cache GET responses
			cache: true,
			//Used to handle the raw response data of XMLHttpRequest.
			//This is a pre-filtering function to sanitize the response.
			//The sanitized response should be returned
			dataFilter: empty
		}

		function mimeToDataType( mime ) {
			if ( mime ) mime = mime.split( ';', 2 )[ 0 ]
			return mime && (mime == htmlType ? 'html' :
					mime == jsonType ? 'json' :
						scriptTypeRE.test( mime ) ? 'script' :
						xmlTypeRE.test( mime ) && 'xml') || 'text'
		}

		function appendQuery( url, query ) {
			if ( query == '' ) return url
			return (url + '&' + query).replace( /[&?]{1,2}/, '?' )
		}

		// serialize payload and append it to the URL for GET requests
		function serializeData( options ) {
			if ( options.processData && options.data && $.type( options.data ) != "string" )
				options.data = $.param( options.data, options.traditional )
			if ( options.data && (!options.type || options.type.toUpperCase() == 'GET' || 'jsonp' == options.dataType) )
				options.url = appendQuery( options.url, options.data ), options.data = undefined
		}

		$.ajax = function ( options ) {
			var settings = $.extend( {}, options || {} ),
				deferred = $.Deferred && $.Deferred(),
				urlAnchor, hashIndex
			for ( key in $.ajaxSettings )
				if ( settings[ key ] === undefined ) settings[ key ] = $.ajaxSettings[ key ]

			ajaxStart( settings )

			if ( !settings.crossDomain ) {
				urlAnchor = document.createElement( 'a' )
				urlAnchor.href = settings.url
				// cleans up URL for .href (IE only), see https://github.com/madrobby/zepto/pull/1049
				urlAnchor.href = urlAnchor.href
				settings.crossDomain = (originAnchor.protocol + '//' + originAnchor.host) !== (urlAnchor.protocol + '//' + urlAnchor.host)
			}

			if ( !settings.url ) settings.url = window.location.toString()
			if ( (hashIndex = settings.url.indexOf( '#' )) > -1 ) settings.url = settings.url.slice( 0, hashIndex )
			serializeData( settings )

			var dataType = settings.dataType,
				hasPlaceholder = /\?.+=\?/.test( settings.url )
			if ( hasPlaceholder ) dataType = 'jsonp'

			if ( settings.cache === false || (
					(!options || options.cache !== true) &&
					('script' == dataType || 'jsonp' == dataType)
				) )
				settings.url = appendQuery( settings.url, '_=' + Date.now() )

			if ( 'jsonp' == dataType ) {
				if ( !hasPlaceholder )
					settings.url = appendQuery( settings.url,
						settings.jsonp ? (settings.jsonp + '=?') : settings.jsonp === false ? '' : 'callback=?' )
				return $.ajaxJSONP( settings, deferred )
			}

			var mime = settings.accepts[ dataType ],
				headers = {},
				setHeader = function ( name, value ) {
					headers[ name.toLowerCase() ] = [ name, value ]
				},
				protocol = /^([\w-]+:)\/\//.test( settings.url ) ? RegExp.$1 : window.location.protocol,
				xhr = settings.xhr(),
				nativeSetHeader = xhr.setRequestHeader,
				abortTimeout

			if ( deferred ) deferred.promise( xhr )

			if ( !settings.crossDomain ) setHeader( 'X-Requested-With', 'XMLHttpRequest' )
			setHeader( 'Accept', mime || '*/*' )
			if ( mime = settings.mimeType || mime ) {
				if ( mime.indexOf( ',' ) > -1 ) mime = mime.split( ',', 2 )[ 0 ]
				xhr.overrideMimeType && xhr.overrideMimeType( mime )
			}
			if ( settings.contentType || (settings.contentType !== false && settings.data && settings.type.toUpperCase() != 'GET') )
				setHeader( 'Content-Type', settings.contentType || 'application/x-www-form-urlencoded' )

			if ( settings.headers )
				for ( name in settings.headers ) setHeader( name, settings.headers[ name ] )
			xhr.setRequestHeader = setHeader

			xhr.onreadystatechange = function () {
				if ( xhr.readyState == 4 ) {
					xhr.onreadystatechange = empty
					clearTimeout( abortTimeout )
					var result, error = false
					if ( (xhr.status >= 200 && xhr.status < 300) || xhr.status == 304 || (xhr.status == 0 && protocol == 'file:') ) {
						dataType = dataType || mimeToDataType( settings.mimeType || xhr.getResponseHeader( 'content-type' ) )

						if ( xhr.responseType == 'arraybuffer' || xhr.responseType == 'blob' )
							result = xhr.response
						else {
							result = xhr.responseText

							try {
								// http://perfectionkills.com/global-eval-what-are-the-options/
								// sanitize response accordingly if data filter callback provided
								result = ajaxDataFilter( result, dataType, settings )
								if ( dataType == 'script' )(1, eval)( result )
								else if ( dataType == 'xml' ) result = xhr.responseXML
								else if ( dataType == 'json' ) result = blankRE.test( result ) ? null : $.parseJSON( result )
							} catch ( e ) {
								error = e
							}

							if ( error ) return ajaxError( error, 'parsererror', xhr, settings, deferred )
						}

						ajaxSuccess( result, xhr, settings, deferred )
					} else {
						ajaxError( xhr.statusText || null, xhr.status ? 'error' : 'abort', xhr, settings, deferred )
					}
				}
			}

			if ( ajaxBeforeSend( xhr, settings ) === false ) {
				xhr.abort()
				ajaxError( null, 'abort', xhr, settings, deferred )
				return xhr
			}

			var async = 'async' in settings ? settings.async : true
			xhr.open( settings.type, settings.url, async, settings.username, settings.password )

			if ( settings.xhrFields )
				for ( name in settings.xhrFields ) xhr[ name ] = settings.xhrFields[ name ]

			for ( name in headers ) nativeSetHeader.apply( xhr, headers[ name ] )

			if ( settings.timeout > 0 ) abortTimeout = setTimeout( function () {
				xhr.onreadystatechange = empty
				xhr.abort()
				ajaxError( null, 'timeout', xhr, settings, deferred )
			}, settings.timeout )

			// avoid sending empty string (#319)
			xhr.send( settings.data ? settings.data : null )
			return xhr
		}

		// handle optional data/success arguments
		function parseArguments( url, data, success, dataType ) {
			if ( $.isFunction( data ) ) dataType = success, success = data, data = undefined
			if ( !$.isFunction( success ) ) dataType = success, success = undefined
			return {
				url: url,
				data: data,
				success: success,
				dataType: dataType
			}
		}

		$.get = function ( /* url, data, success, dataType */ ) {
			return $.ajax( parseArguments.apply( null, arguments ) )
		}

		$.post = function ( /* url, data, success, dataType */ ) {
			var options = parseArguments.apply( null, arguments )
			options.type = 'POST'
			return $.ajax( options )
		}

		$.getJSON = function ( /* url, data, success */ ) {
			var options = parseArguments.apply( null, arguments )
			options.dataType = 'json'
			return $.ajax( options )
		}

		$.fn.load = function ( url, data, success ) {
			if ( !this.length ) return this
			var self = this,
				parts = url.split( /\s/ ),
				selector,
				options = parseArguments( url, data, success ),
				callback = options.success
			if ( parts.length > 1 ) options.url = parts[ 0 ], selector = parts[ 1 ]
			options.success = function ( response ) {
				self.html( selector ?
					$( '<div>' ).html( response.replace( rscript, "" ) ).find( selector ) :
					response )
				callback && callback.apply( self, arguments )
			}
			$.ajax( options )
			return this
		}

		var escape = encodeURIComponent

		function serialize( params, obj, traditional, scope ) {
			var type, array = $.isArray( obj ),
				hash = $.isPlainObject( obj )
			$.each( obj, function ( key, value ) {
				type = $.type( value )
				if ( scope ) key = traditional ? scope :
				scope + '[' + (hash || type == 'object' || type == 'array' ? key : '') + ']'
				// handle data in serializeArray() format
				if ( !scope && array ) params.add( value.name, value.value )
				// recurse into nested objects
				else if ( type == "array" || (!traditional && type == "object") )
					serialize( params, value, traditional, key )
				else params.add( key, value )
			} )
		}

		$.param = function ( obj, traditional ) {
			var params = []
			params.add = function ( key, value ) {
				if ( $.isFunction( value ) ) value = value()
				if ( value == null ) value = ""
				this.push( escape( key ) + '=' + escape( value ) )
			}
			serialize( params, obj, traditional )
			return params.join( '&' ).replace( /%20/g, '+' )
		}
	})( Zepto )

	;
	(function ( $ ) {
		$.fn.serializeArray = function () {
			var name, type, result = [],
				add = function ( value ) {
					if ( value.forEach ) return value.forEach( add )
					result.push( {
						name: name,
						value: value
					} )
				}
			if ( this[ 0 ] ) $.each( this[ 0 ].elements, function ( _, field ) {
				type = field.type, name = field.name
				if ( name && field.nodeName.toLowerCase() != 'fieldset' && !field.disabled && type != 'submit' && type != 'reset' && type != 'button' && type != 'file' &&
					((type != 'radio' && type != 'checkbox') || field.checked) )
					add( $( field ).val() )
			} )
			return result
		}

		$.fn.serialize = function () {
			var result = []
			this.serializeArray().forEach( function ( elm ) {
				result.push( encodeURIComponent( elm.name ) + '=' + encodeURIComponent( elm.value ) )
			} )
			return result.join( '&' )
		}

		$.fn.submit = function ( callback ) {
			if ( 0 in arguments ) this.bind( 'submit', callback )
			else if ( this.length ) {
				var event = $.Event( 'submit' )
				this.eq( 0 ).trigger( event )
				if ( !event.isDefaultPrevented() ) this.get( 0 ).submit()
			}
			return this
		}

	})( Zepto )

	;
	(function () {
		// getComputedStyle shouldn't freak out when called
		// without a valid element as argument
		try {
			getComputedStyle( undefined )
		} catch ( e ) {
			var nativeGetComputedStyle = getComputedStyle
			window.getComputedStyle = function ( element, pseudoElement ) {
				try {
					return nativeGetComputedStyle( element, pseudoElement )
				} catch ( e ) {
					return null
				}
			}
		}
	})()
	return Zepto
} ))
